package Week3;

import java.io.*;
import java.util.*;

public class Day15 {
}

//牛客:平方数
class Main6 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        long x = in.nextLong();
        //判断这个数开根号之后左右两个数的平⽅，哪个最近即可
        long a = (long)Math.sqrt(x);
        long x1 = a * a , x2 = (a + 1) * (a + 1);
        if(x - x1 < x2 - x) System.out.println(x1);
        else System.out.println(x2);
    }
}

//牛客:分组
class Main7 {
    static int n , m;
    static Map<Integer,Integer> hash = new HashMap<>();
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        n = in.nextInt();
        m = in.nextInt();
        int hmax = 0;
        //计算每个元素的个数，和最大的元素个数
        for(int i = 0; i < n; i++){
            int x = in.nextInt();
            hash.put(x , hash.getOrDefault(x , 0) + 1);
            hmax = Math.max(hmax , hash.get(x));
        }

        //处理边界情况，如果我们学生擅长的声部种类是多余我们的组数的就无法顺利分组
        if(hash.size() > m){
            System.out.println(-1);
        }else{
            //暴力枚举
            //根据我们的最大个数，来决定每组最多的人数情况
            for(int i = 1; i <= hmax; i++){
                //传入此时的最大人数i,判断是否能够成功的进行分组
                if(check(i)){
                    System.out.println(i);
                    break;
                }
            }

//             //二分查找优化
//             int left = 1 ,right = hmax;
//             while(left < right){
//                 int mid = (left + right) / 2;
//                 if(check(mid)) right = mid;
//                 else left = mid + 1;
//             }
//             System.out.println(left);
        }
    }

    //判断最大人数为x时，是否能够分成m组
    public static boolean check(int x){
        int g = 0; //统计能分成多少组
        //遍历哈希表中每个每个元素的个数
        for(int a : hash.values()){
            //根据此时每组的最大人数，判断每个元素能够分成几组（a / x），如果除不尽有余数，剩下的余数依然可以形成一组(a % x == 0 ? 0 : 1)
            //将所有元素形成的组数加在一起就此时一组为x所能形成的组数
            g += a / x + (a % x == 0 ? 0 : 1);
        }
        //如果组数是小于等于m的那么i就是可以进行分组的最大人数
        //至于为什么要小于m因为可能我们最终所有的分组情况都不会完全等于m,但小于m也可以成立是因为虽然此时我们的组个数是小于m的，但是我们可以取出一些相同的元素再形成几个组凑成m个组
        return g <= m;
    }
}

//牛客:AB13 【模板】拓扑排序
class Main8 {
    public static void main(String[] args) throws IOException{
        Read1 in = new Read1();
        int n = in.nextInt() , m = in.nextInt();
        //邻接表存储图
        Map<Integer,List<Integer>> edges = new HashMap<>();
        //统计入度值
        int[] cnt = new int[n+1];
        //建图
        for(int i = 0; i < m; i++){
            int a = in.nextInt() , b = in.nextInt();
            //此时a->b，b的入度加一
            cnt[b]++;
            //如果不存在a,放入
            if(!edges.containsKey(a)){
                edges.put(a,new ArrayList<>());
            }
            //存在就将与a相连的b放到a的值中
            edges.get(a).add(b);
        }

        //创建队列，将入度为0的点放入其中
        Queue<Integer> q = new LinkedList<>();
        for(int i = 1; i <= n; i++){
            if(cnt[i] == 0){
                q.add(i);
            }
        }

        //统计结果
        int[] ret = new int[n];
        int pos = 0;

        //bfs
        while(!q.isEmpty()){
            int t = q.poll();
            ret[pos++] = t;
            //遍历t后面所有相连的元素，但可能t此时是最后一个元素后面找不到任何的元素，所以我们要给他置为空数组
            for(int b : edges.getOrDefault(t , new ArrayList<>())){
                //此时b元素的入度减一
                cnt[b]--;
                //如果入度为0，入队列
                if(cnt[b] == 0){
                    q.add(b);
                }
            }
        }

        //判断是否成环，当然此题不用判断因为已经告诉我们是无环图了
        //判断是否成环的方法，就是判断是否还有入度不为0的点
        // for(int x : cnt){
        //     if(x != 0) return false;
        // }

        //如果此时数组的长度为个数n
        if(pos == n){
            //输出结果，但是要注意最后一个数后面没有空格
            for(int i = 0; i < n-1; i++){
                System.out.print(ret[i] + " ");
            }
            System.out.print(ret[n - 1]);
        }else{//长度不为个数n
            System.out.print(-1);
        }

    }
}
class Read1 {
    StringTokenizer st = new StringTokenizer("");
    BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
    String next() throws IOException {
        while (!st.hasMoreTokens()) {
            st = new StringTokenizer(bf.readLine());
        }
        return st.nextToken();
    }
    String nextLine() throws IOException {
        return bf.readLine();
    }

    int nextInt() throws IOException {
        return Integer.parseInt(next());
    }

    long nextLong() throws IOException {
        return Long.parseLong(next());
    }

    double nextDouble() throws IOException {
        return Double.parseDouble(next());
    }
}